Clojure এ নেমস্পেস এবং স্কোপ (Namespaces and Scope in Clojure)

ক্লোজারে (Clojure) নেমস্পেস এবং স্কোপ প্রোগ্রামকে সংগঠিত ও নিয়ন্ত্রিত করার জন্য অত্যন্ত গুরুত্বপূর্ণ। নেমস্পেস বিভিন্ন ভেরিয়েবল, ফাংশন, এবং ডেটাকে একটি নির্দিষ্ট স্কোপে গঠন করে রাখে, যাতে কোডের সংঘর্ষ কমে এবং বিভিন্ন মডিউল বা লাইব্রেরির মধ্যে সহজে ইন্টারঅ্যাক্ট করা যায়।

নেমস্পেস (Namespace)

নেমস্পেস হলো ক্লোজারের একটি বিশেষ ফিচার, যা বিভিন্ন ফাংশন, ভেরিয়েবল, এবং ডেটাকে একটি নির্দিষ্ট গঠনবদ্ধ পরিবেশে সংরক্ষণ করে। এটি প্রোগ্রামিংয়ের সময় নেম সংঘর্ষ এড়াতে সহায়ক।

১. নেমস্পেস তৈরি করা

ক্লোজারে ns ফর্ম ব্যবহার করে নেমস্পেস তৈরি করা যায়। সাধারণত একটি নতুন ফাইলের শুরুর দিকে ns ঘোষণা করা হয়।

(ns my-namespace)

এখানে, my-namespace নামে একটি নতুন নেমস্পেস তৈরি করা হলো।

২. নেমস্পেসে ফাংশন এবং ভেরিয়েবল সংজ্ঞায়িত করা

নেমস্পেসের মধ্যে def এবং defn ব্যবহার করে ভেরিয়েবল এবং ফাংশন সংজ্ঞায়িত করা যায়।

(ns my-namespace)

(def x 10) ; ভেরিয়েবল সংজ্ঞায়িত করা
(defn যোগফল [a b] ; ফাংশন সংজ্ঞায়িত করা
  (+ a b))

৩. অন্যান্য নেমস্পেস থেকে ফাংশন আমদানি (Importing Functions from Other Namespaces)

require, use, বা refer ফর্ম ব্যবহার করে একটি নেমস্পেস থেকে অন্য নেমস্পেসের ফাংশন বা ভেরিয়েবল আমদানি করা যায়।

• require: নির্দিষ্ট নেমস্পেস আমদানি করা হয় এবং :as ব্যবহার করে একটি শর্টকাট নাম নির্ধারণ করা যায়।

  (ns my-app
    (:require [my-namespace :as m]))
  
  (m/যোগফল ৫ ৩) ; আউটপুট: ৮

• use: সম্পূর্ণ নেমস্পেসের সমস্ত ফাংশন ডিফল্টভাবে ইমপোর্ট করে।

  (ns my-app
    (:use my-namespace))
  
  (যোগফল ৫ ৩) ; আউটপুট: ৮

• refer: নির্দিষ্ট কিছু ফাংশন বা ভেরিয়েবল আমদানি করতে ব্যবহৃত হয়।

  (ns my-app
    (:require [my-namespace :refer [যোগফল]]))
  
  (যোগফল ৫ ৩) ; আউটপুট: ৮

৪. Java ক্লাস আমদানি করা

ক্লোজারে নেমস্পেসে জাভা ক্লাস ব্যবহার করার জন্য :import ফর্ম ব্যবহার করা যায়।

(ns my-app
  (:import [java.util Date]))

(Date.) ; বর্তমান তারিখ ও সময় প্রদান করে

স্কোপ (Scope)

ক্লোজারে স্কোপ বলতে বোঝানো হয় যেখানে একটি ভেরিয়েবল বা ফাংশন কার্যকর হয়। ক্লোজারে সাধারণত দুটি ধরনের স্কোপ আছে: গ্লোবাল স্কোপ এবং লোকাল স্কোপ।

১. গ্লোবাল স্কোপ (Global Scope)

def ব্যবহার করে ক্লোজারে গ্লোবাল স্কোপ তৈরি করা যায়। গ্লোবাল স্কোপে ঘোষিত ভেরিয়েবল বা ফাংশন পুরো নেমস্পেসে কার্যকর থাকে।

(def global-var 42)

এখানে global-var পুরো নেমস্পেসে ব্যবহৃত হতে পারে।

২. লোকাল স্কোপ (Local Scope)

ক্লোজারে let, loop, এবং ফাংশনের মাধ্যমে লোকাল স্কোপ তৈরি করা হয়। লোকাল স্কোপের ভেরিয়েবল কেবল সেই স্কোপের ভিতরে কার্যকর থাকে।

• let: let ফর্ম লোকাল স্কোপে ভেরিয়েবল তৈরি করতে ব্যবহৃত হয়।

  (let [x 10
        y 20]
    (+ x y)) ; আউটপুট: 30

  এখানে, x এবং y কেবল let ব্লকের ভিতরে কার্যকর এবং তার বাইরে ব্যবহার করা যাবে না।

• loop: loop এবং recur ব্যবহার করে পুনরাবৃত্তিমূলক লোকাল স্কোপ তৈরি করা যায়।

  (loop [i 5]
    (when (pos? i)
      (println i)
      (recur (dec i))))
  ; আউটপুট: ৫ ৪ ৩ ২ ১

নেমস্পেস এবং স্কোপ ব্যবহারের সুবিধা

• সংঘর্ষ এড়ানো: নেমস্পেস বিভিন্ন মডিউলের মধ্যে সংঘর্ষ এড়াতে সাহায্য করে, কারণ প্রতিটি নেমস্পেসে আলাদা স্কোপ থাকে।
• কোড সংরক্ষণ এবং পুনর্ব্যবহারযোগ্যতা: নেমস্পেস এবং স্কোপ কোডকে গঠনবদ্ধভাবে সংরক্ষণ করে এবং সহজে পুনরায় ব্যবহারযোগ্য করে তোলে।
• ডিবাগিং সহজ: স্কোপের কারণে কোন ভেরিয়েবল কোথায় কার্যকর হবে তা স্পষ্ট থাকে, যা ডিবাগ করতে সাহায্য করে।

উদাহরণ: একটি পূর্ণাঙ্গ নেমস্পেস ব্যবহারের উদাহরণ

; my_math.clj ফাইল
(ns my-math)

(defn যোগফল [a b]
  (+ a b))

(defn বর্গ [x]
  (* x x))

; main.clj ফাইল
(ns main
  (:require [my-math :as math]))

(println (math/যোগফল ১০ ২০)) ; আউটপুট: ৩০
(println (math/বর্গ ৫)) ; আউটপুট: ২৫

এখানে, my-math নামে একটি নেমস্পেসে গণিতের ফাংশন তৈরি করা হয়েছে এবং main নেমস্পেসে এটি আমদানি করে ব্যবহার করা হচ্ছে।

সারসংক্ষেপ

ক্লোজারে নেমস্পেস প্রোগ্রামিংকে গঠনবদ্ধ করে তোলে এবং বিভিন্ন মডিউলের মধ্যে সংঘর্ষ এড়াতে সাহায্য করে। স্কোপ, ভেরিয়েবলের কার্যকারিতা নির্ধারণ করে এবং বিভিন্ন অংশে ভিন্ন মান ব্যবহারের সুযোগ দেয়। নেমস্পেস এবং স্কোপের সঠিক ব্যবহারের মাধ্যমে ক্লোজারে বড় ও জটিল প্রজেক্ট পরিচালনা করা সহজ হয়।

ক্লোজার (Clojure) এর Namespace এবং তার প্রয়োজনীয়তা

Namespace ক্লোজারের একটি গুরুত্বপূর্ণ ধারণা, যা প্রজেক্টে ব্যবহৃত ফাংশন, ভ্যারিয়েবল এবং ডেটা স্ট্রাকচারগুলিকে সংগঠিত ও আলাদা রাখতে সহায়ক। এটি কোডের নাম সংঘর্ষ (name collision) প্রতিরোধ করে এবং বড় প্রজেক্টে কোডকে গঠনমূলকভাবে বিভক্ত করে ব্যবহারের সুবিধা প্রদান করে।

Namespace কী?

Namespace মূলত একটি লজিক্যাল স্পেস বা পরিবেশ যেখানে একটি নির্দিষ্ট নামের সাথে সম্পর্কিত সব ফাংশন এবং ডেটা সংরক্ষিত থাকে। এর মাধ্যমে একই নামে থাকা ভিন্ন ভিন্ন ফাংশন এবং ভ্যারিয়েবলকে আলাদা করা যায়। উদাহরণস্বরূপ, math নামে একটি namespace-এ গণিত সম্পর্কিত ফাংশন থাকতে পারে এবং string নামে আরেকটি namespace-এ স্ট্রিং সম্পর্কিত ফাংশন থাকতে পারে।

Namespace তৈরির উদ্দেশ্য এবং প্রয়োজনীয়তা

Namespace ব্যবহারের প্রধান কারণগুলি হলো:

1. নাম সংঘর্ষ (Name Collision) এড়ানো: বড় প্রজেক্টে বিভিন্ন মডিউল বা লাইব্রেরি থেকে একই নামের ফাংশন ব্যবহার করলে সংঘর্ষ হতে পারে। Namespace প্রতিটি মডিউলকে আলাদা রাখে, ফলে একই নামের ভিন্ন ফাংশনও ব্যবহারে অসুবিধা হয় না।
2. কোড সংগঠিত রাখা: Namespace কোডকে গঠনমূলকভাবে বিভক্ত ও সংগঠিত করে রাখে, ফলে কোড পড়া, ডিবাগিং ও রক্ষণাবেক্ষণ করা সহজ হয়।
3. আন্তর্জাতিক মানের প্রজেক্টে প্রয়োজন: বড় স্কেল এবং আন্তর্জাতিক মানের প্রজেক্টে কোডের নামের সংঘর্ষ প্রতিরোধ এবং মডিউল ও প্যাকেজ ব্যবস্থাপনা গুরুত্বপূর্ণ হয়ে ওঠে। Namespace এক্ষেত্রে কার্যকরী সমাধান প্রদান করে।

Namespace কিভাবে তৈরি এবং ব্যবহার করা হয়?

ক্লোজারে ns কীওয়ার্ড ব্যবহার করে namespace তৈরি করা যায়। নিচে কয়েকটি উদাহরণ এবং ধাপ দেওয়া হলো।

উদাহরণ: Namespace তৈরি

(ns myproject.math)

(defn add [a b]
  (+ a b))

(defn subtract [a b]
  (- a b))

এখানে, myproject.math নামে একটি namespace তৈরি করা হয়েছে যেখানে দুটি ফাংশন add এবং subtract সংজ্ঞায়িত করা হয়েছে।

Namespace ব্যবহার করা এবং অন্য Namespace থেকে ফাংশন আমদানি

Namespace ব্যবহারের জন্য প্রথমে এটিকে require করতে হয়। যেমন:

(ns myproject.main
  (:require [myproject.math :as math]))

(math/add 10 5)      ; আউটপুট: 15
(math/subtract 10 5) ; আউটপুট: 5

এখানে, myproject.math namespace-কে myproject.main namespace-এ :as বিকল্প দিয়ে math নামে অ্যাক্সেস করা হয়েছে। এখন math/add এবং math/subtract ফাংশনগুলো myproject.main namespace-এ ব্যবহার করা যাচ্ছে।

Namespace এর অন্যান্য গুরুত্বপূর্ণ কমান্ড

• require: অন্য namespace-কে বর্তমান namespace-এ ব্যবহার করতে আমদানি করা হয়।
• use: পুরো namespace-কে বর্তমান namespace-এ এনে ফাংশনগুলো সরাসরি ব্যবহার করা যায় (তবে বড় প্রজেক্টে নাম সংঘর্ষ হতে পারে)।
• alias: as অপশন দিয়ে নির্দিষ্ট namespace-কে একটি সংক্ষিপ্ত নামে অ্যাক্সেস করতে দেওয়া হয়।

উদাহরণ: use এবং alias

(ns myproject.core
  (:use [myproject.math]))  ; `use` দিয়ে সরাসরি ব্যবহার করা

(add 10 5)       ; আউটপুট: 15
(subtract 10 5)  ; আউটপুট: 5

(ns myproject.main
  (:require [myproject.math :as m]))  ; `alias` দিয়ে সংক্ষিপ্ত নাম

(m/add 10 5)      ; আউটপুট: 15
(m/subtract 10 5) ; আউটপুট: 5

Namespace এর সুবিধা

1. নাম সংঘর্ষ এড়ানো: একই নামের ভিন্ন ফাংশন বিভিন্ন namespace-এ রাখা যায়।
2. কোডের পাঠযোগ্যতা বৃদ্ধি: Namespace ব্যবহার করে কোডকে গঠনমূলক এবং পড়তে সহজ রাখা যায়।
3. বড় প্রজেক্টে সহজ রক্ষণাবেক্ষণ: কোড মডিউল এবং সাব-মডিউলে বিভক্ত থাকায় রক্ষণাবেক্ষণ ও ডিবাগিং সহজ হয়।
4. দ্রুত অ্যাক্সেস: Alias ব্যবহার করে বড় namespace-কে ছোট নামে অ্যাক্সেস করা যায়।

সারসংক্ষেপ

Namespace ক্লোজারের একটি শক্তিশালী বৈশিষ্ট্য যা বড় এবং জটিল প্রজেক্টে কোড মডুলারাইজেশন, নাম সংঘর্ষ এড়ানো এবং পাঠযোগ্যতা বৃদ্ধিতে সহায়ক। Namespace এর মাধ্যমে ফাংশন এবং ভ্যারিয়েবলগুলো আলাদা রাখা যায় এবং এটি প্রজেক্টের গঠনমূলক বৈশিষ্ট্য নিশ্চিত করে, যা দীর্ঘমেয়াদে কোড রক্ষণাবেক্ষণের জন্য অত্যন্ত গুরুত্বপূর্ণ।

ns, require, এবং use এর মাধ্যমে Namespace তৈরি

ক্লোজার (Clojure) এ namespace একটি অত্যন্ত গুরুত্বপূর্ণ ধারণা, যেটি কোডের সংগঠন এবং মডুলারিটি সহজতর করতে সাহায্য করে। একটি namespace হল কোডের একটি logical নাম, যা কোডের বিভিন্ন অংশকে একত্রিত করে এবং তাদের মধ্যে সম্পর্ক তৈরি করে। ক্লোজারে ns, require, এবং use এর মাধ্যমে namespace তৈরি এবং ব্যবহারের প্রক্রিয়া অনেক সহজ এবং কার্যকরী।

১. ns এর মাধ্যমে Namespace তৈরি

ns (namespace) একটি ম্যাক্রো যা একটি নতুন namespace তৈরি করতে ব্যবহৃত হয়। এটি সাধারণত কোডের শুরুর দিকে ব্যবহার করা হয় এবং এতে namespace এর নাম এবং অন্যান্য কনফিগারেশন উল্লেখ করা হয়।

Syntax:

(ns namespace-name
  (:require [other-namespace :as alias]))

উদাহরণ: ns ব্যবহার করে Namespace তৈরি

(ns my-app.core
  (:require [clojure.string :as str]))

(defn greeting [name]
  (str "Hello, " name "!"))

এখানে, my-app.core namespace তৈরি করা হয়েছে এবং clojure.string namespace কে str নামে অ্যালিয়াস দিয়ে require করা হয়েছে।

২. require এর মাধ্যমে Namespace Import

require হল একটি কনফিগারেশন ম্যাক্রো যা অন্য namespace থেকে ফাংশন বা মান ইনক্লুড করতে ব্যবহৃত হয়। require নামস্পেস বা লাইব্রেরি কল করার সময় তার কার্যকরী অংশকে ব্যবহারযোগ্য করে তোলে।

Syntax:

(ns your-namespace
  (:require [namespace-to-import :as alias]))

• namespace-to-import: যে namespace বা লাইব্রেরি থেকে ফাংশন এবং মানগুলো আনা হবে।
• alias: ইচ্ছেমতো নাম যা আপনি ইনক্লুড করা namespace এর জন্য ব্যবহার করতে চান।

উদাহরণ: require এর মাধ্যমে Namespace Import

(ns my-app.core
  (:require [clojure.string :as str]))

(defn shout [text]
  (str/upper-case text))

এখানে clojure.string namespace কে str নামে অ্যালিয়াস দেওয়া হয়েছে এবং upper-case ফাংশনটি ব্যবহার করা হয়েছে।

৩. use এর মাধ্যমে Namespace Import

use একটি পুরনো কৌশল যা একটি namespace এর সমস্ত নাম (functions, variables) সরাসরি বর্তমান namespace এ নিয়ে আসে। এর মাধ্যমে আপনি নির্দিষ্ট namespace এর সব ফাংশন বা ভ্যারিয়েবল ব্যবহার করতে পারেন, তবে এটি require এর তুলনায় কিছুটা ঝুঁকিপূর্ণ হতে পারে কারণ এটি namespace থেকে সব কিছুই এনে দেয় এবং এভাবে নাম সংঘর্ষ হতে পারে।

নোট: বর্তমান ক্লোজার সংস্করণে use ব্যবহার করা কমে গেছে এবং require সাধারণত বেশি ব্যবহৃত হয়, কারণ এটি আরো নির্দিষ্ট এবং সুরক্ষিত।

Syntax:

(ns your-namespace
  (:use [namespace-to-import]))

উদাহরণ: use এর মাধ্যমে Namespace Import

(ns my-app.core
  (:use [clojure.string]))

(defn shout [text]
  (upper-case text))

এখানে clojure.string namespace এর সকল ফাংশন সরাসরি ব্যবহার করা হয়েছে, যেমন upper-case ফাংশনটি।

৪. Namespace এর মধ্যে ফাংশন ব্যবহার

একটি namespace তৈরি করার পর, অন্য namespace থেকে ফাংশন বা মান ব্যবহার করা সম্ভব। require বা use এর মাধ্যমে যে namespace ইম্পোর্ট করা হয়, তার ফাংশনগুলো ব্যবহার করা যায়।

উদাহরণ: একাধিক namespace এর ফাংশন ব্যবহার

(ns my-app.core
  (:require [clojure.string :as str]))

(defn greet [name]
  (str/join " " ["Hello" name]))

(defn shout [name]
  (str/upper-case (greet name)))

এখানে, my-app.core namespace তে clojure.string এর join এবং upper-case ফাংশন দুটি ব্যবহার করা হয়েছে।

৫. Namespace ও Aliases

require ব্যবহার করার সময় আপনি ইচ্ছামতো একটি namespace এর জন্য alias দিতে পারেন, যা কোডে ব্যবহার করা আরও সহজ করে তোলে। এটি বড় প্রোজেক্টে নামগুলোর সাথে সংঘর্ষ এড়াতে সাহায্য করে এবং কোডের পাঠযোগ্যতা বাড়ায়।

উদাহরণ: Namespace এর Alias ব্যবহার

(ns my-app.core
  (:require [clojure.string :as str]))

(defn shout [name]
  (str/upper-case (str/join " " ["Hello" name])))

এখানে, clojure.string namespace কে str নামে অ্যালিয়াস দেওয়া হয়েছে, যা কোডকে আরও সংক্ষিপ্ত এবং পরিষ্কার করে তোলে।

সারসংক্ষেপ

ক্লোজারে namespace ব্যবহার করা কোডের সংগঠন এবং স্কেলেবিলিটির জন্য অত্যন্ত গুরুত্বপূর্ণ। require এবং use দিয়ে অন্য namespace থেকে ফাংশন ও মান আমদানি করা যায়, এবং ns দিয়ে নতুন namespace তৈরি করা হয়।

Fully Qualified Names (FQNs) এবং Aliases in Clojure

ক্লোজার (Clojure) প্রোগ্রামিং ভাষায় Fully Qualified Names (FQNs) এবং Aliases ব্যবহার করা হয় যাতে কোডটি আরও পরিষ্কার এবং সুসংগঠিত হয়। এই ধারণাগুলো নামের সংঘর্ষ (name clashes) এবং মডিউল ব্যবস্থাপনা (module management) থেকে রক্ষা পেতে সাহায্য করে। Clojure-এ বিভিন্ন লাইব্রেরি এবং স্পেসিফিক নামের ব্যবহারের জন্য এই দুটি গুরুত্বপূর্ণ বৈশিষ্ট্য ব্যবহার করা হয়।

১. Fully Qualified Names (FQNs)

Fully Qualified Names (FQNs) হলো একটি নির্দিষ্ট নাম স্পেস (namespace) সহ সম্পূর্ণ নাম যা একটি ক্লাস, ফাংশন বা ভ্যারিয়েবলকে সুনির্দিষ্টভাবে চিহ্নিত করে। Clojure-এ, যখন কোনো ক্লাস বা ফাংশন অন্যান্য লাইব্রেরি বা নামস্পেসে থাকে, তখন তাদের ব্যবহার করার জন্য তাদের সম্পূর্ণ নাম দিতে হয়।

FQN এর গঠন:

namespace/name

• namespace: এটি হলো নামস্পেসের নাম যেখানে ফাংশন বা ভ্যারিয়েবল সংরক্ষিত থাকে।
• name: এটি হলো ফাংশন, ভ্যারিয়েবল বা ক্লাসের নাম।

উদাহরণ: FQN ব্যবহার

ধরা যাক, আমরা clojure.string নামস্পেস থেকে join ফাংশন ব্যবহার করতে চাই:

(clojure.string/join "-" ["Hello" "World"])  ; আউটপুট: "Hello-World"

এখানে, clojure.string/join হলো একটি Fully Qualified Name (FQN), যা join ফাংশনকে clojure.string নামস্পেসের অন্তর্গত হিসাবে চিহ্নিত করে।

২. Aliases (এলিয়াস)

ক্লোজারে alias ব্যবহার করে আপনি কোনো দীর্ঘ নামস্পেসের জন্য ছোট নাম (shortcut) নির্ধারণ করতে পারেন। এটি কোড লেখা এবং পড়া সহজ করে তোলে। require ফাংশন ব্যবহার করে নামস্পেসে একটি এলিয়াস অ্যাসাইন করা হয়। এলিয়াস ব্যবহারের ফলে কোডটি আরও পরিষ্কার এবং কমপ্যাক্ট হয়।

এলিয়াস ব্যবহার:

(ns my-namespace
  (:require [clojure.string :as str]))  ; 'clojure.string' কে 'str' নাম দিয়ে এলিয়াস করলাম

(str/join "-" ["Hello" "World"])  ; আউটপুট: "Hello-World"

এখানে, আমরা clojure.string নামস্পেসকে str নামে এলিয়াস দিয়েছি, যাতে clojure.string/join লেখার পরিবর্তে শুধুমাত্র str/join ব্যবহার করতে পারি। এটি কোডের পাঠযোগ্যতা এবং লিখনক্ষমতা বৃদ্ধি করে।

৩. require এবং as Keyword

Clojure-এ নামস্পেস ব্যবহার করার জন্য সাধারণভাবে require ফাংশনটি ব্যবহার করা হয়। এই ফাংশনটি আপনার নামস্পেসে অন্য একটি নামস্পেসকে অন্তর্ভুক্ত (include) করার জন্য ব্যবহৃত হয় এবং সেখানে এলিয়াস অ্যাসাইন করা সম্ভব।

সিনট্যাক্স:

(ns your-namespace
  (:require [some.namespace :as alias]))

এখানে, some.namespace নামস্পেসের ফাংশন বা ক্লাসগুলির জন্য alias নামটি ব্যবহার করা হবে।

উদাহরণ: এলিয়াস ও require ফাংশন

(ns my-namespace
  (:require [clojure.set :as set]))  ; 'clojure.set' কে 'set' নামে এলিয়াস করলাম

(def example-set (set/union #{1 2 3} #{3 4 5}))  ; আউটপুট: #{1 2 3 4 5}

এখানে, আমরা clojure.set নামস্পেসকে set এলিয়াস দিয়ে অন্তর্ভুক্ত করেছি এবং union ফাংশনটি set/union এর মাধ্যমে ব্যবহার করেছি।

৪. Multiple Aliases

একই নামস্পেসে একাধিক এলিয়াস ব্যবহারও সম্ভব। আপনি একাধিক নামস্পেসের জন্য বিভিন্ন এলিয়াস অ্যাসাইন করতে পারেন।

উদাহরণ: একাধিক এলিয়াস ব্যবহার

(ns my-namespace
  (:require [clojure.string :as str]
            [clojure.set :as set]))

(str/join "-" ["Hello" "World"])  ; আউটপুট: "Hello-World"
(set/union #{1 2 3} #{3 4 5})     ; আউটপুট: #{1 2 3 4 5}

এখানে, আমরা দুটি আলাদা নামস্পেস clojure.string এবং clojure.set এর জন্য str এবং set এলিয়াস ব্যবহার করেছি।

৫. Namespace Reflection

ক্লোজারে নামস্পেস রিফ্লেকশন ব্যবহার করে আপনি বর্তমান নামস্পেসের সম্পর্কে তথ্য জানতে পারেন। আপনি জানতে পারবেন কোনো নামস্পেসে কোন ফাংশন বা ভ্যারিয়েবল আছে।

উদাহরণ: Namespace Reflection

(ns my-namespace
  (:require [clojure.string :as str]))

(keys (ns-publics 'clojure.string))  ; আউটপুট: (blank? capitalize join ... )

এখানে, ns-publics ফাংশন ব্যবহার করে আমরা clojure.string নামস্পেসের সমস্ত পাবলিক ফাংশনের নাম দেখতে পাচ্ছি।

সারসংক্ষেপ

• Fully Qualified Names (FQNs): কোনো ফাংশন বা ভ্যারিয়েবলের সম্পূর্ণ নাম যা নামস্পেস সহ নির্দিষ্ট করা হয় (যেমন: clojure.string/join).
• Aliases: নামস্পেসে একটি ছোট নাম (shortcut) নির্ধারণ করার জন্য ব্যবহৃত হয়, যা কোড লেখা সহজ করে (যেমন: clojure.string কে str এলিয়াস দেওয়া).
• require: অন্য নামস্পেস ব্যবহার করার জন্য require ফাংশনটি ব্যবহৃত হয়, যেখানে এলিয়াসও দেওয়া যায়।

এই দুটি বৈশিষ্ট্য, FQNs এবং Aliases, Clojure-এ কোডের পরিচ্ছন্নতা এবং মডুলারিটি বজায় রাখতে সাহায্য করে, বিশেষ করে যখন আপনি অনেক লাইব্রেরি এবং নামস্পেসের সাথে কাজ করছেন।

Scope এবং Variable Binding এর কাজ

ক্লোজার (Clojure) একটি ফাংশনাল প্রোগ্রামিং ভাষা, যেখানে Scope (স্কোপ) এবং Variable Binding (ভেরিয়েবল বাইন্ডিং) এর ধারণাগুলি প্রোগ্রামিংয়ের মূল অংশ। এই দুটি ধারণা ভেরিয়েবলগুলোর জীবনকাল এবং অ্যাক্সেস নিয়ন্ত্রণ করতে সহায়ক, এবং ডেটা ম্যানিপুলেশন ও ফাংশনাল প্রোগ্রামিংয়ে গুরুত্বপূর্ণ ভূমিকা পালন করে।

১. Scope (স্কোপ)

Scope হল একটি প্রোগ্রাম অংশ যেখানে একটি ভেরিয়েবল বা নাম কার্যকর থাকে। এটি একটি ভেরিয়েবলের দৃশ্যমানতা এবং অ্যাক্সেস নিয়ন্ত্রণ করে, যার ফলে একটি ভেরিয়েবল কোথায় এবং কখন ব্যবহৃত হতে পারে তা নির্ধারণ করা হয়। স্কোপের দুটি প্রধান ধরনের বিভাজন:

• Global Scope (গ্লোবাল স্কোপ): এটি প্রোগ্রামের বাইরের এলাকা, যেখানে ডিফাইন্ড সমস্ত ভেরিয়েবল সমস্ত ফাংশন বা ব্লক দ্বারা অ্যাক্সেসযোগ্য হয় (যদি না তারা লোকাল স্কোপে ব্যবহার করা হয়)।
• Local Scope (লোকাল স্কোপ): এটি একটি নির্দিষ্ট ফাংশন বা ব্লকের ভেতরে ব্যবহৃত ভেরিয়েবলগুলির স্কোপ। এই স্কোপে ডিফাইন্ড ভেরিয়েবল শুধুমাত্র সেই ফাংশন বা ব্লকের ভেতরেই অ্যাক্সেসযোগ্য থাকে।

উদাহরণ: Scope in Clojure

(def global-var 10) ; গ্লোবাল স্কোপ

(defn my-function []
  (let [local-var 5] ; লোকাল স্কোপ
    (println "Global Var: " global-var) ; global-var অ্যাক্সেস করা যাবে
    (println "Local Var: " local-var)))  ; local-var অ্যাক্সেস করা যাবে

(my-function)
(println global-var) ; আউটপুট: 10
(println local-var)  ; এই লাইনটি এরর দিবে, কারণ local-var লোকাল স্কোপে।

এখানে, global-var একটি গ্লোবাল স্কোপে ডিফাইন করা হয়েছে, তাই এটি ফাংশনের বাইরে কোথাও অ্যাক্সেস করা যেতে পারে। তবে local-var শুধুমাত্র my-function এর ভিতরে অ্যাক্সেসযোগ্য, এবং বাইরের কোডে এটি অ্যাক্সেস করা সম্ভব নয়।

২. Variable Binding (ভেরিয়েবল বাইন্ডিং)

Variable Binding হল ভেরিয়েবলের জন্য একটি মান নির্ধারণ করা এবং সেই মানটি ভেরিয়েবলের সাথে "বাইন্ড" করা। ক্লোজারে বিভিন্নভাবে ভেরিয়েবল বাইন্ড করা হয়, এবং এর বিভিন্ন প্রক্রিয়া ভেরিয়েবলের জীবনকাল এবং স্কোপ নিয়ন্ত্রণ করে। সাধারণত ভেরিয়েবল বাইন্ডিংয়ের জন্য def, let, binding, এবং with ব্লক ব্যবহার করা হয়।

১. def - গ্লোবাল ভেরিয়েবল বাইন্ডিং

def ব্যবহার করে একটি ভেরিয়েবল গ্লোবাল স্কোপে বাইন্ড করা হয়, অর্থাৎ এটি প্রোগ্রামের যেকোনো স্থানে অ্যাক্সেসযোগ্য।

(def my-var 42) ; গ্লোবাল স্কোপে বাইন্ডিং

(println my-var) ; আউটপুট: 42

২. let - লোকাল ভেরিয়েবল বাইন্ডিং

let ব্যবহার করে একটি লোকাল স্কোপে ভেরিয়েবল বাইন্ড করা হয়। let একটি ব্লকের মধ্যে ভেরিয়েবলগুলি ডিফাইন করে এবং সেই ভেরিয়েবলগুলির মান ব্লকটির মধ্যে সীমাবদ্ধ থাকে।

(let [x 10
      y 20]
  (+ x y)) ; আউটপুট: 30

এখানে, x এবং y একটি লোকাল স্কোপে বাইন্ড করা হয়েছে এবং তারা শুধুমাত্র let ব্লকের ভিতরে অ্যাক্সেসযোগ্য।

৩. binding - ডাইনামিক বাইন্ডিং

binding ব্যবহার করে ডাইনামিক স্কোপে ভেরিয়েবল বাইন্ড করা হয়, যা ঐ স্কোপের মধ্যে সমস্ত ফাংশনে পরিবর্তনশীল মান প্রয়োগ করে। binding সাধারণত যখন আপনাকে মানগুলি প্রোগ্রামের চলাকালীন সময়ে পরিবর্তন করতে হয় তখন ব্যবহৃত হয়।

(def ^:dynamic *my-dynamic-var* 100) ; ডাইনামিক স্কোপে বাইন্ডিং

(defn example-fn []
  (println *my-dynamic-var*))

(binding [*my-dynamic-var* 200]  ; ডাইনামিক স্কোপে মান পরিবর্তন
  (example-fn)) ; আউটপুট: 200

এখানে, *my-dynamic-var* ডাইনামিকভাবে বাইন্ড করা হয়েছে, এবং binding ব্লকটির ভিতরে এর মান পরিবর্তিত হয়েছে।

৪. with - সময়কালের জন্য ভেরিয়েবল বাইন্ডিং

with ব্যবহার করে একটি ভেরিয়েবল এক নির্দিষ্ট সময়কাল (scope) জন্য বাইন্ড করা হয়, সাধারণত কোন বিশেষ কাঠামো বা সিস্টেমের জন্য এটি ব্যবহার করা হয় (যেমন লগিং, রিসোর্স ম্যানেজমেন্ট, ইত্যাদি)।

(with-open [rdr (clojure.java.io/reader "file.txt")]
  (println (slurp rdr)))

এখানে, with-open একটি নির্দিষ্ট সময়ের জন্য rdr ভেরিয়েবলটি বাইন্ড করে এবং ফাইলটি খুলে পড়ে।

Variable Binding এর কাজ

ভেরিয়েবল বাইন্ডিং মূলত দুটি প্রধান কাজ করে:

1. ভেরিয়েবল তৈরির এবং মান নির্ধারণের প্রক্রিয়া: যখন কোনো ভেরিয়েবল ডিফাইন করা হয়, তখন তার জন্য একটি মান নির্ধারণ করা হয়।
2. ভেরিয়েবলের স্কোপ নিয়ন্ত্রণ: বাইন্ডিংয়ের মাধ্যমে, একটি ভেরিয়েবল নির্দিষ্ট স্কোপে কার্যকর থাকে, যেমন গ্লোবাল স্কোপে বা লোকাল স্কোপে। এতে ভেরিয়েবলটির অ্যাক্সেস এবং জীবনকাল নিয়ন্ত্রণ করা হয়।

Summary

স্কোপ এবং ভেরিয়েবল বাইন্ডিংয়ের মাধ্যমে ক্লোজারে ভেরিয়েবলগুলির অ্যাক্সেস, জীবনকাল, এবং তাদের মানের পরিবর্তন নিয়ন্ত্রণ করা হয়, যা ফাংশনাল প্রোগ্রামিংয়ের মডুলার কোডিং এবং প্রোগ্রাম ডিবাগিংয়ের জন্য অপরিহার্য।